Termination w.r.t. Q of the following Term Rewriting System could not be shown:

Q restricted rewrite system:
The TRS R consists of the following rules:

dbl1(0) -> 0
dbl1(s1(X)) -> s1(s1(dbl1(X)))
dbls1(nil) -> nil
dbls1(cons2(X, Y)) -> cons2(dbl1(X), dbls1(Y))
sel2(0, cons2(X, Y)) -> X
sel2(s1(X), cons2(Y, Z)) -> sel2(X, Z)
indx2(nil, X) -> nil
indx2(cons2(X, Y), Z) -> cons2(sel2(X, Z), indx2(Y, Z))
from1(X) -> cons2(X, from1(s1(X)))
dbl11(0) -> 01
dbl11(s1(X)) -> s11(s11(dbl11(X)))
sel12(0, cons2(X, Y)) -> X
sel12(s1(X), cons2(Y, Z)) -> sel12(X, Z)
quote1(0) -> 01
quote1(s1(X)) -> s11(quote1(X))
quote1(dbl1(X)) -> dbl11(X)
quote1(sel2(X, Y)) -> sel12(X, Y)

Q is empty.


↳ QTRS
  ↳ DependencyPairsProof

Q restricted rewrite system:
The TRS R consists of the following rules:

dbl1(0) -> 0
dbl1(s1(X)) -> s1(s1(dbl1(X)))
dbls1(nil) -> nil
dbls1(cons2(X, Y)) -> cons2(dbl1(X), dbls1(Y))
sel2(0, cons2(X, Y)) -> X
sel2(s1(X), cons2(Y, Z)) -> sel2(X, Z)
indx2(nil, X) -> nil
indx2(cons2(X, Y), Z) -> cons2(sel2(X, Z), indx2(Y, Z))
from1(X) -> cons2(X, from1(s1(X)))
dbl11(0) -> 01
dbl11(s1(X)) -> s11(s11(dbl11(X)))
sel12(0, cons2(X, Y)) -> X
sel12(s1(X), cons2(Y, Z)) -> sel12(X, Z)
quote1(0) -> 01
quote1(s1(X)) -> s11(quote1(X))
quote1(dbl1(X)) -> dbl11(X)
quote1(sel2(X, Y)) -> sel12(X, Y)

Q is empty.

Using Dependency Pairs [1,13] we result in the following initial DP problem:
Q DP problem:
The TRS P consists of the following rules:

QUOTE1(sel2(X, Y)) -> SEL12(X, Y)
DBL11(s1(X)) -> DBL11(X)
QUOTE1(s1(X)) -> QUOTE1(X)
INDX2(cons2(X, Y), Z) -> SEL2(X, Z)
QUOTE1(dbl1(X)) -> DBL11(X)
DBLS1(cons2(X, Y)) -> DBL1(X)
SEL2(s1(X), cons2(Y, Z)) -> SEL2(X, Z)
DBLS1(cons2(X, Y)) -> DBLS1(Y)
SEL12(s1(X), cons2(Y, Z)) -> SEL12(X, Z)
DBL1(s1(X)) -> DBL1(X)
FROM1(X) -> FROM1(s1(X))
INDX2(cons2(X, Y), Z) -> INDX2(Y, Z)

The TRS R consists of the following rules:

dbl1(0) -> 0
dbl1(s1(X)) -> s1(s1(dbl1(X)))
dbls1(nil) -> nil
dbls1(cons2(X, Y)) -> cons2(dbl1(X), dbls1(Y))
sel2(0, cons2(X, Y)) -> X
sel2(s1(X), cons2(Y, Z)) -> sel2(X, Z)
indx2(nil, X) -> nil
indx2(cons2(X, Y), Z) -> cons2(sel2(X, Z), indx2(Y, Z))
from1(X) -> cons2(X, from1(s1(X)))
dbl11(0) -> 01
dbl11(s1(X)) -> s11(s11(dbl11(X)))
sel12(0, cons2(X, Y)) -> X
sel12(s1(X), cons2(Y, Z)) -> sel12(X, Z)
quote1(0) -> 01
quote1(s1(X)) -> s11(quote1(X))
quote1(dbl1(X)) -> dbl11(X)
quote1(sel2(X, Y)) -> sel12(X, Y)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

QUOTE1(sel2(X, Y)) -> SEL12(X, Y)
DBL11(s1(X)) -> DBL11(X)
QUOTE1(s1(X)) -> QUOTE1(X)
INDX2(cons2(X, Y), Z) -> SEL2(X, Z)
QUOTE1(dbl1(X)) -> DBL11(X)
DBLS1(cons2(X, Y)) -> DBL1(X)
SEL2(s1(X), cons2(Y, Z)) -> SEL2(X, Z)
DBLS1(cons2(X, Y)) -> DBLS1(Y)
SEL12(s1(X), cons2(Y, Z)) -> SEL12(X, Z)
DBL1(s1(X)) -> DBL1(X)
FROM1(X) -> FROM1(s1(X))
INDX2(cons2(X, Y), Z) -> INDX2(Y, Z)

The TRS R consists of the following rules:

dbl1(0) -> 0
dbl1(s1(X)) -> s1(s1(dbl1(X)))
dbls1(nil) -> nil
dbls1(cons2(X, Y)) -> cons2(dbl1(X), dbls1(Y))
sel2(0, cons2(X, Y)) -> X
sel2(s1(X), cons2(Y, Z)) -> sel2(X, Z)
indx2(nil, X) -> nil
indx2(cons2(X, Y), Z) -> cons2(sel2(X, Z), indx2(Y, Z))
from1(X) -> cons2(X, from1(s1(X)))
dbl11(0) -> 01
dbl11(s1(X)) -> s11(s11(dbl11(X)))
sel12(0, cons2(X, Y)) -> X
sel12(s1(X), cons2(Y, Z)) -> sel12(X, Z)
quote1(0) -> 01
quote1(s1(X)) -> s11(quote1(X))
quote1(dbl1(X)) -> dbl11(X)
quote1(sel2(X, Y)) -> sel12(X, Y)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [13,14,18] contains 8 SCCs with 4 less nodes.

↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
            ↳ QDPOrderProof
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

SEL12(s1(X), cons2(Y, Z)) -> SEL12(X, Z)

The TRS R consists of the following rules:

dbl1(0) -> 0
dbl1(s1(X)) -> s1(s1(dbl1(X)))
dbls1(nil) -> nil
dbls1(cons2(X, Y)) -> cons2(dbl1(X), dbls1(Y))
sel2(0, cons2(X, Y)) -> X
sel2(s1(X), cons2(Y, Z)) -> sel2(X, Z)
indx2(nil, X) -> nil
indx2(cons2(X, Y), Z) -> cons2(sel2(X, Z), indx2(Y, Z))
from1(X) -> cons2(X, from1(s1(X)))
dbl11(0) -> 01
dbl11(s1(X)) -> s11(s11(dbl11(X)))
sel12(0, cons2(X, Y)) -> X
sel12(s1(X), cons2(Y, Z)) -> sel12(X, Z)
quote1(0) -> 01
quote1(s1(X)) -> s11(quote1(X))
quote1(dbl1(X)) -> dbl11(X)
quote1(sel2(X, Y)) -> sel12(X, Y)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].


The following pairs can be oriented strictly and are deleted.


SEL12(s1(X), cons2(Y, Z)) -> SEL12(X, Z)
The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial interpretation [21]:

POL(SEL12(x1, x2)) = x1   
POL(cons2(x1, x2)) = 0   
POL(s1(x1)) = 1 + x1   

The following usable rules [14] were oriented: none



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
            ↳ QDPOrderProof
              ↳ QDP
                ↳ PisEmptyProof
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

dbl1(0) -> 0
dbl1(s1(X)) -> s1(s1(dbl1(X)))
dbls1(nil) -> nil
dbls1(cons2(X, Y)) -> cons2(dbl1(X), dbls1(Y))
sel2(0, cons2(X, Y)) -> X
sel2(s1(X), cons2(Y, Z)) -> sel2(X, Z)
indx2(nil, X) -> nil
indx2(cons2(X, Y), Z) -> cons2(sel2(X, Z), indx2(Y, Z))
from1(X) -> cons2(X, from1(s1(X)))
dbl11(0) -> 01
dbl11(s1(X)) -> s11(s11(dbl11(X)))
sel12(0, cons2(X, Y)) -> X
sel12(s1(X), cons2(Y, Z)) -> sel12(X, Z)
quote1(0) -> 01
quote1(s1(X)) -> s11(quote1(X))
quote1(dbl1(X)) -> dbl11(X)
quote1(sel2(X, Y)) -> sel12(X, Y)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
            ↳ QDPOrderProof
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

DBL11(s1(X)) -> DBL11(X)

The TRS R consists of the following rules:

dbl1(0) -> 0
dbl1(s1(X)) -> s1(s1(dbl1(X)))
dbls1(nil) -> nil
dbls1(cons2(X, Y)) -> cons2(dbl1(X), dbls1(Y))
sel2(0, cons2(X, Y)) -> X
sel2(s1(X), cons2(Y, Z)) -> sel2(X, Z)
indx2(nil, X) -> nil
indx2(cons2(X, Y), Z) -> cons2(sel2(X, Z), indx2(Y, Z))
from1(X) -> cons2(X, from1(s1(X)))
dbl11(0) -> 01
dbl11(s1(X)) -> s11(s11(dbl11(X)))
sel12(0, cons2(X, Y)) -> X
sel12(s1(X), cons2(Y, Z)) -> sel12(X, Z)
quote1(0) -> 01
quote1(s1(X)) -> s11(quote1(X))
quote1(dbl1(X)) -> dbl11(X)
quote1(sel2(X, Y)) -> sel12(X, Y)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].


The following pairs can be oriented strictly and are deleted.


DBL11(s1(X)) -> DBL11(X)
The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial interpretation [21]:

POL(DBL11(x1)) = x1   
POL(s1(x1)) = 1 + x1   

The following usable rules [14] were oriented: none



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
            ↳ QDPOrderProof
              ↳ QDP
                ↳ PisEmptyProof
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

dbl1(0) -> 0
dbl1(s1(X)) -> s1(s1(dbl1(X)))
dbls1(nil) -> nil
dbls1(cons2(X, Y)) -> cons2(dbl1(X), dbls1(Y))
sel2(0, cons2(X, Y)) -> X
sel2(s1(X), cons2(Y, Z)) -> sel2(X, Z)
indx2(nil, X) -> nil
indx2(cons2(X, Y), Z) -> cons2(sel2(X, Z), indx2(Y, Z))
from1(X) -> cons2(X, from1(s1(X)))
dbl11(0) -> 01
dbl11(s1(X)) -> s11(s11(dbl11(X)))
sel12(0, cons2(X, Y)) -> X
sel12(s1(X), cons2(Y, Z)) -> sel12(X, Z)
quote1(0) -> 01
quote1(s1(X)) -> s11(quote1(X))
quote1(dbl1(X)) -> dbl11(X)
quote1(sel2(X, Y)) -> sel12(X, Y)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ QDPOrderProof
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE1(s1(X)) -> QUOTE1(X)

The TRS R consists of the following rules:

dbl1(0) -> 0
dbl1(s1(X)) -> s1(s1(dbl1(X)))
dbls1(nil) -> nil
dbls1(cons2(X, Y)) -> cons2(dbl1(X), dbls1(Y))
sel2(0, cons2(X, Y)) -> X
sel2(s1(X), cons2(Y, Z)) -> sel2(X, Z)
indx2(nil, X) -> nil
indx2(cons2(X, Y), Z) -> cons2(sel2(X, Z), indx2(Y, Z))
from1(X) -> cons2(X, from1(s1(X)))
dbl11(0) -> 01
dbl11(s1(X)) -> s11(s11(dbl11(X)))
sel12(0, cons2(X, Y)) -> X
sel12(s1(X), cons2(Y, Z)) -> sel12(X, Z)
quote1(0) -> 01
quote1(s1(X)) -> s11(quote1(X))
quote1(dbl1(X)) -> dbl11(X)
quote1(sel2(X, Y)) -> sel12(X, Y)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].


The following pairs can be oriented strictly and are deleted.


QUOTE1(s1(X)) -> QUOTE1(X)
The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial interpretation [21]:

POL(QUOTE1(x1)) = x1   
POL(s1(x1)) = 1 + x1   

The following usable rules [14] were oriented: none



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ QDPOrderProof
              ↳ QDP
                ↳ PisEmptyProof
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

dbl1(0) -> 0
dbl1(s1(X)) -> s1(s1(dbl1(X)))
dbls1(nil) -> nil
dbls1(cons2(X, Y)) -> cons2(dbl1(X), dbls1(Y))
sel2(0, cons2(X, Y)) -> X
sel2(s1(X), cons2(Y, Z)) -> sel2(X, Z)
indx2(nil, X) -> nil
indx2(cons2(X, Y), Z) -> cons2(sel2(X, Z), indx2(Y, Z))
from1(X) -> cons2(X, from1(s1(X)))
dbl11(0) -> 01
dbl11(s1(X)) -> s11(s11(dbl11(X)))
sel12(0, cons2(X, Y)) -> X
sel12(s1(X), cons2(Y, Z)) -> sel12(X, Z)
quote1(0) -> 01
quote1(s1(X)) -> s11(quote1(X))
quote1(dbl1(X)) -> dbl11(X)
quote1(sel2(X, Y)) -> sel12(X, Y)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

FROM1(X) -> FROM1(s1(X))

The TRS R consists of the following rules:

dbl1(0) -> 0
dbl1(s1(X)) -> s1(s1(dbl1(X)))
dbls1(nil) -> nil
dbls1(cons2(X, Y)) -> cons2(dbl1(X), dbls1(Y))
sel2(0, cons2(X, Y)) -> X
sel2(s1(X), cons2(Y, Z)) -> sel2(X, Z)
indx2(nil, X) -> nil
indx2(cons2(X, Y), Z) -> cons2(sel2(X, Z), indx2(Y, Z))
from1(X) -> cons2(X, from1(s1(X)))
dbl11(0) -> 01
dbl11(s1(X)) -> s11(s11(dbl11(X)))
sel12(0, cons2(X, Y)) -> X
sel12(s1(X), cons2(Y, Z)) -> sel12(X, Z)
quote1(0) -> 01
quote1(s1(X)) -> s11(quote1(X))
quote1(dbl1(X)) -> dbl11(X)
quote1(sel2(X, Y)) -> sel12(X, Y)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ QDPOrderProof
          ↳ QDP
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

SEL2(s1(X), cons2(Y, Z)) -> SEL2(X, Z)

The TRS R consists of the following rules:

dbl1(0) -> 0
dbl1(s1(X)) -> s1(s1(dbl1(X)))
dbls1(nil) -> nil
dbls1(cons2(X, Y)) -> cons2(dbl1(X), dbls1(Y))
sel2(0, cons2(X, Y)) -> X
sel2(s1(X), cons2(Y, Z)) -> sel2(X, Z)
indx2(nil, X) -> nil
indx2(cons2(X, Y), Z) -> cons2(sel2(X, Z), indx2(Y, Z))
from1(X) -> cons2(X, from1(s1(X)))
dbl11(0) -> 01
dbl11(s1(X)) -> s11(s11(dbl11(X)))
sel12(0, cons2(X, Y)) -> X
sel12(s1(X), cons2(Y, Z)) -> sel12(X, Z)
quote1(0) -> 01
quote1(s1(X)) -> s11(quote1(X))
quote1(dbl1(X)) -> dbl11(X)
quote1(sel2(X, Y)) -> sel12(X, Y)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].


The following pairs can be oriented strictly and are deleted.


SEL2(s1(X), cons2(Y, Z)) -> SEL2(X, Z)
The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial interpretation [21]:

POL(SEL2(x1, x2)) = x1   
POL(cons2(x1, x2)) = 0   
POL(s1(x1)) = 1 + x1   

The following usable rules [14] were oriented: none



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ QDPOrderProof
              ↳ QDP
                ↳ PisEmptyProof
          ↳ QDP
          ↳ QDP
          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

dbl1(0) -> 0
dbl1(s1(X)) -> s1(s1(dbl1(X)))
dbls1(nil) -> nil
dbls1(cons2(X, Y)) -> cons2(dbl1(X), dbls1(Y))
sel2(0, cons2(X, Y)) -> X
sel2(s1(X), cons2(Y, Z)) -> sel2(X, Z)
indx2(nil, X) -> nil
indx2(cons2(X, Y), Z) -> cons2(sel2(X, Z), indx2(Y, Z))
from1(X) -> cons2(X, from1(s1(X)))
dbl11(0) -> 01
dbl11(s1(X)) -> s11(s11(dbl11(X)))
sel12(0, cons2(X, Y)) -> X
sel12(s1(X), cons2(Y, Z)) -> sel12(X, Z)
quote1(0) -> 01
quote1(s1(X)) -> s11(quote1(X))
quote1(dbl1(X)) -> dbl11(X)
quote1(sel2(X, Y)) -> sel12(X, Y)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ QDPOrderProof
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

INDX2(cons2(X, Y), Z) -> INDX2(Y, Z)

The TRS R consists of the following rules:

dbl1(0) -> 0
dbl1(s1(X)) -> s1(s1(dbl1(X)))
dbls1(nil) -> nil
dbls1(cons2(X, Y)) -> cons2(dbl1(X), dbls1(Y))
sel2(0, cons2(X, Y)) -> X
sel2(s1(X), cons2(Y, Z)) -> sel2(X, Z)
indx2(nil, X) -> nil
indx2(cons2(X, Y), Z) -> cons2(sel2(X, Z), indx2(Y, Z))
from1(X) -> cons2(X, from1(s1(X)))
dbl11(0) -> 01
dbl11(s1(X)) -> s11(s11(dbl11(X)))
sel12(0, cons2(X, Y)) -> X
sel12(s1(X), cons2(Y, Z)) -> sel12(X, Z)
quote1(0) -> 01
quote1(s1(X)) -> s11(quote1(X))
quote1(dbl1(X)) -> dbl11(X)
quote1(sel2(X, Y)) -> sel12(X, Y)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].


The following pairs can be oriented strictly and are deleted.


INDX2(cons2(X, Y), Z) -> INDX2(Y, Z)
The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial interpretation [21]:

POL(INDX2(x1, x2)) = x1   
POL(cons2(x1, x2)) = 1 + x2   

The following usable rules [14] were oriented: none



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ QDPOrderProof
              ↳ QDP
                ↳ PisEmptyProof
          ↳ QDP
          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

dbl1(0) -> 0
dbl1(s1(X)) -> s1(s1(dbl1(X)))
dbls1(nil) -> nil
dbls1(cons2(X, Y)) -> cons2(dbl1(X), dbls1(Y))
sel2(0, cons2(X, Y)) -> X
sel2(s1(X), cons2(Y, Z)) -> sel2(X, Z)
indx2(nil, X) -> nil
indx2(cons2(X, Y), Z) -> cons2(sel2(X, Z), indx2(Y, Z))
from1(X) -> cons2(X, from1(s1(X)))
dbl11(0) -> 01
dbl11(s1(X)) -> s11(s11(dbl11(X)))
sel12(0, cons2(X, Y)) -> X
sel12(s1(X), cons2(Y, Z)) -> sel12(X, Z)
quote1(0) -> 01
quote1(s1(X)) -> s11(quote1(X))
quote1(dbl1(X)) -> dbl11(X)
quote1(sel2(X, Y)) -> sel12(X, Y)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ QDPOrderProof
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

DBL1(s1(X)) -> DBL1(X)

The TRS R consists of the following rules:

dbl1(0) -> 0
dbl1(s1(X)) -> s1(s1(dbl1(X)))
dbls1(nil) -> nil
dbls1(cons2(X, Y)) -> cons2(dbl1(X), dbls1(Y))
sel2(0, cons2(X, Y)) -> X
sel2(s1(X), cons2(Y, Z)) -> sel2(X, Z)
indx2(nil, X) -> nil
indx2(cons2(X, Y), Z) -> cons2(sel2(X, Z), indx2(Y, Z))
from1(X) -> cons2(X, from1(s1(X)))
dbl11(0) -> 01
dbl11(s1(X)) -> s11(s11(dbl11(X)))
sel12(0, cons2(X, Y)) -> X
sel12(s1(X), cons2(Y, Z)) -> sel12(X, Z)
quote1(0) -> 01
quote1(s1(X)) -> s11(quote1(X))
quote1(dbl1(X)) -> dbl11(X)
quote1(sel2(X, Y)) -> sel12(X, Y)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].


The following pairs can be oriented strictly and are deleted.


DBL1(s1(X)) -> DBL1(X)
The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial interpretation [21]:

POL(DBL1(x1)) = x1   
POL(s1(x1)) = 1 + x1   

The following usable rules [14] were oriented: none



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ QDPOrderProof
              ↳ QDP
                ↳ PisEmptyProof
          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

dbl1(0) -> 0
dbl1(s1(X)) -> s1(s1(dbl1(X)))
dbls1(nil) -> nil
dbls1(cons2(X, Y)) -> cons2(dbl1(X), dbls1(Y))
sel2(0, cons2(X, Y)) -> X
sel2(s1(X), cons2(Y, Z)) -> sel2(X, Z)
indx2(nil, X) -> nil
indx2(cons2(X, Y), Z) -> cons2(sel2(X, Z), indx2(Y, Z))
from1(X) -> cons2(X, from1(s1(X)))
dbl11(0) -> 01
dbl11(s1(X)) -> s11(s11(dbl11(X)))
sel12(0, cons2(X, Y)) -> X
sel12(s1(X), cons2(Y, Z)) -> sel12(X, Z)
quote1(0) -> 01
quote1(s1(X)) -> s11(quote1(X))
quote1(dbl1(X)) -> dbl11(X)
quote1(sel2(X, Y)) -> sel12(X, Y)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ QDPOrderProof

Q DP problem:
The TRS P consists of the following rules:

DBLS1(cons2(X, Y)) -> DBLS1(Y)

The TRS R consists of the following rules:

dbl1(0) -> 0
dbl1(s1(X)) -> s1(s1(dbl1(X)))
dbls1(nil) -> nil
dbls1(cons2(X, Y)) -> cons2(dbl1(X), dbls1(Y))
sel2(0, cons2(X, Y)) -> X
sel2(s1(X), cons2(Y, Z)) -> sel2(X, Z)
indx2(nil, X) -> nil
indx2(cons2(X, Y), Z) -> cons2(sel2(X, Z), indx2(Y, Z))
from1(X) -> cons2(X, from1(s1(X)))
dbl11(0) -> 01
dbl11(s1(X)) -> s11(s11(dbl11(X)))
sel12(0, cons2(X, Y)) -> X
sel12(s1(X), cons2(Y, Z)) -> sel12(X, Z)
quote1(0) -> 01
quote1(s1(X)) -> s11(quote1(X))
quote1(dbl1(X)) -> dbl11(X)
quote1(sel2(X, Y)) -> sel12(X, Y)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].


The following pairs can be oriented strictly and are deleted.


DBLS1(cons2(X, Y)) -> DBLS1(Y)
The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial interpretation [21]:

POL(DBLS1(x1)) = x1   
POL(cons2(x1, x2)) = 1 + x2   

The following usable rules [14] were oriented: none



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ QDPOrderProof
              ↳ QDP
                ↳ PisEmptyProof

Q DP problem:
P is empty.
The TRS R consists of the following rules:

dbl1(0) -> 0
dbl1(s1(X)) -> s1(s1(dbl1(X)))
dbls1(nil) -> nil
dbls1(cons2(X, Y)) -> cons2(dbl1(X), dbls1(Y))
sel2(0, cons2(X, Y)) -> X
sel2(s1(X), cons2(Y, Z)) -> sel2(X, Z)
indx2(nil, X) -> nil
indx2(cons2(X, Y), Z) -> cons2(sel2(X, Z), indx2(Y, Z))
from1(X) -> cons2(X, from1(s1(X)))
dbl11(0) -> 01
dbl11(s1(X)) -> s11(s11(dbl11(X)))
sel12(0, cons2(X, Y)) -> X
sel12(s1(X), cons2(Y, Z)) -> sel12(X, Z)
quote1(0) -> 01
quote1(s1(X)) -> s11(quote1(X))
quote1(dbl1(X)) -> dbl11(X)
quote1(sel2(X, Y)) -> sel12(X, Y)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.